home *** CD-ROM | disk | FTP | other *** search
/ Speccy ClassiX 1998 / Speccy ClassiX 98.iso / amiga_system / the_aminet / dev / gcc / ixemulsrc.lha / ixemul-41.4 / library / open.c < prev    next >
C/C++ Source or Header  |  1995-10-02  |  8KB  |  264 lines
  1. /*
  2.  *  This file is part of ixemul.library for the Amiga.
  3.  *  Copyright (C) 1991, 1992  Markus M. Wild
  4.  *  Portions Copyright (C) 1994 Rafael W. Luebbert
  5.  *
  6.  *  This library is free software; you can redistribute it and/or
  7.  *  modify it under the terms of the GNU Library General Public
  8.  *  License as published by the Free Software Foundation; either
  9.  *  version 2 of the License, or (at your option) any later version.
  10.  *
  11.  *  This library is distributed in the hope that it will be useful,
  12.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14.  *  Library General Public License for more details.
  15.  *
  16.  *  You should have received a copy of the GNU Library General Public
  17.  *  License along with this library; if not, write to the Free
  18.  *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  *
  20.  *  $Id: open.c,v 1.4 1994/06/19 15:14:07 rluebbert Exp $
  21.  *
  22.  *  $Log: open.c,v $
  23.  *  Revision 1.4  1994/06/19  15:14:07  rluebbert
  24.  *  *** empty log message ***
  25.  *
  26.  *  Revision 1.2  1992/07/28  00:32:04  mwild
  27.  *  pass convert_dir the original signal mask, to check for pending signals
  28.  *
  29.  *  Revision 1.1  1992/05/14  19:55:40  mwild
  30.  *  Initial revision
  31.  *
  32.  */
  33.  
  34. #define KERNEL
  35. #include "ixemul.h"
  36. #include "kprintf.h"
  37.  
  38. /* standard functions.. could get overridden in a network environment */
  39. extern int __ioctl (), __fselect (), __close ();
  40.  
  41. /* "normal" functions, means do half-async writes & sync reads */
  42. extern int __write (), __read ();
  43.  
  44. /* sync-write, waits for completion of write, this gets enabled by
  45.  * O_FSYNC */
  46. extern int __sync_write ();
  47.  
  48. extern void __fasync_handler ();
  49.  
  50. /* incore functions */
  51. extern int __mread (), __mclose ();
  52.  
  53. extern int __ioerr_to_errno ();
  54.  
  55.  
  56. int
  57. open (char *name, int mode, int perms)
  58. {
  59.   int fd;
  60.   struct file *f;
  61.   BPTR fh;
  62.   int len, late_stat;
  63.   int omask, error = 0;
  64.   int amode, fnofs;
  65.  
  66.   if (name == NULL)     /* sanity check */
  67.     return EACCES;
  68.   mode = FFLAGS(mode);
  69.  
  70.   KPRINTF (("open1: write (2,.. %s.\n", write (2, "WR2", 3) == 3 ? "works" : "doesn't work"));
  71.  
  72.   /* inhibit signals */
  73.   omask = syscall (SYS_sigsetmask, ~0);
  74.  
  75.   errno = falloc (&f, &fd);
  76.   KPRINTF (("&errno = %lx, errno = %ld\n", &errno, errno));
  77.   if (errno != 0)
  78.     {
  79.       syscall (SYS_sigsetmask, omask);
  80.       return -1;
  81.     }
  82.   /* we now got the file, ie. since its count is > 0, no other process
  83.    * will get it with falloc() */
  84.  
  85.   KPRINTF (("open2: write (2,.. %s.\n", write (2, "WR2", 3) == 3 ? "works" : "doesn't work"));
  86.  
  87.   KPRINTF (("open3: write (2,.. %s.\n", write (2, "WR2", 3) == 3 ? "works" : "doesn't work"));
  88.   /* init those fields */
  89.   f->f_stb_dirty = 0;
  90.   late_stat = 0;
  91.   if (syscall (SYS_stat, name, &f->f_stb) < 0)
  92.     {
  93.       /* there can mainly be two reasons for stat() to fail. Either the
  94.        * file really doesn't exist (ENOENT), or then the filesystem/handler
  95.        * doesn't support file locks. */
  96.  
  97.       /* if we should get out of here without an error, init the stat
  98.        * buffer after having opened the file with __fstat, this sets some
  99.        * reasonable parameters (see end of function). */
  100.       late_stat = 1;
  101.  
  102.       if ((errno == ENOENT) && (mode & O_CREAT))
  103.     {
  104.       /* can't set permissions on an open file, so this has to be done
  105.        * by 'close' */
  106.       f->f_stb.st_mode = perms;
  107.       f->f_stb_dirty = 1;
  108.     }
  109.     }
  110.  
  111.   f->f_flags = mode & FMASK;
  112.  
  113.   KPRINTF (("open4: write (2,.. %s.\n", write (2, "WR2", 3) == 3 ? "works" : "doesn't work"));
  114.   /* initialise the packet. The only thing needed at this time is its
  115.    * header, filling in of port, action & args will be done when it's
  116.    * used */
  117.   __init_std_packet (&f->f_sp);
  118.  
  119.   /* ok, so lets try to open the file... */
  120.  
  121.   /* do this *only* if the stat() above was successful !! */
  122.   if (!late_stat && S_ISDIR (f->f_stb.st_mode) && !(mode & FWRITE))
  123.     {
  124.       if (convert_dir (f, name, omask) == 0)
  125.         goto ret_ok;
  126.       else
  127.     goto error;
  128.     }
  129.  
  130.   KPRINTF (("open5: write (2,.. %s.\n", write (2, "WR2", 3) == 3 ? "works" : "doesn't work"));
  131.  
  132.   /* filter invalid modes */
  133.   switch (mode & (O_CREAT|O_TRUNC|O_EXCL))
  134.     {
  135.     case O_EXCL:
  136.     case O_EXCL|O_TRUNC:
  137.       /* can never succeed ! */
  138.       error = EINVAL;
  139.       goto error;
  140.  
  141.     case O_CREAT|O_EXCL:
  142.     case O_CREAT|O_EXCL|O_TRUNC:
  143.       if (! late_stat)
  144.         {
  145.       error = EEXIST;
  146.       goto error;
  147.     }
  148.       break;
  149.     }
  150.  
  151.   amode = (mode & O_CREAT) ? MODE_READWRITE : MODE_OLDFILE;
  152.  
  153.   do
  154.   {
  155.     if (!strcmp(name, "*") || !strcasecmp(name, "console:"))
  156.       /* Temporary patch for KingCON 1.3, which seems to have problems with
  157.      ACTION_FINDINPUT of "*"/"console:" when "dp_Port" of the packet is
  158.      not set to sender's "pr_MsgPort" - that's what IXEmul makes on
  159.      clients' startup during initialization of "stderr". */
  160.       fh=Open(name, amode);
  161.     else
  162.       fh = __open (name, amode);
  163.  
  164.     if (! fh)
  165.       {
  166.         int err = IoErr();
  167.  
  168.         /* For those handlers that do not understand MODE_READWRITE (e.g. PAR: ) */
  169.         if (err == ERROR_ACTION_NOT_KNOWN && amode == MODE_READWRITE)
  170.         {
  171.           amode = MODE_NEWFILE;
  172.         }
  173.         else
  174.         {
  175.           error = __ioerr_to_errno (err);
  176.           goto error;
  177.         }
  178.       }
  179.   } while (!fh);
  180.  
  181.   /* now.. we're lucky, we actually opened the file! */
  182.   f->f_fh = (struct FileHandle *) BTOCPTR(fh);
  183.  
  184.   if (mode & FWRITE)
  185.     f->f_write  = (mode & O_FSYNC) ? __sync_write : __write;
  186.   if (mode & FREAD)
  187.     f->f_read   = __read;
  188.  
  189. #if 0
  190.   /* won't work that way, I'll think something up later.. */
  191.  
  192.   /* in this case, we have to setup a handler that is called when ever
  193.    * something arrives at the rw-port, and then walk our filetable and
  194.    * decide whether the packet belonged to a file that has FASYNC set */
  195.   if (mode & FASYNC) signal (__rwport->mp_SigBit, __fasync_handler);
  196. #endif
  197.  
  198.   f->f_ioctl  = __ioctl;
  199.   f->f_select = __fselect;
  200.   f->f_close  = __close;
  201.   f->f_type   = DTYPE_FILE;
  202.  
  203. ret_ok:
  204.   /*
  205.    * have to use kmalloc() instead of malloc(), because this is no task-private
  206.    * data, it could (in the future) be shared by other tasks 
  207.    */
  208.   f->f_name = (void *) kmalloc (strlen (name) + 1);
  209.   strcpy (f->f_name, name);
  210.  
  211.   /* ok, we're almost done. If desired, init the stat buffer to the
  212.    * information we can get from an open file descriptor */
  213.   if (late_stat) __fstat (f);
  214.   
  215.   /* if the file qualifies, try to change it into a DTYPE_MEM file */
  216.   if (!late_stat && f->f_type == DTYPE_FILE 
  217.       && f->f_stb.st_size < ix.ix_membuf_limit && mode == FREAD)
  218.     {
  219.       void *buf;
  220.       
  221.       KPRINTF (("open6: write (2,.. %s.\n", write (2, "WR2", 3) == 3 ? "works" : "doesn't work"));
  222.       /* try to obtain the needed memory */
  223.       buf = (void *) kmalloc (f->f_stb.st_size);
  224.       if (buf)
  225.     if (syscall (SYS_read, fd, buf, f->f_stb.st_size) == f->f_stb.st_size)
  226.       {
  227.         KPRINTF (("open7: write (2,.. %s.\n", write (2, "WR2", 3) == 3 ? "works" : "doesn't work"));
  228.         __Close (CTOBPTR (f->f_fh));
  229.         KPRINTF (("open8: write (2,.. %s.\n", write (2, "WR2", 3) == 3 ? "works" : "doesn't work"));
  230.         f->f_type         = DTYPE_MEM;
  231.         f->f_mf.mf_offset     = 0;
  232.         f->f_mf.mf_buffer     = buf;
  233.         f->f_read        = __mread;
  234.         f->f_close         = __mclose;
  235.         f->f_ioctl        = 0;
  236.         f->f_select        = 0;
  237.       }
  238.     else
  239.       kfree (buf);
  240.     }
  241.  
  242.   syscall (SYS_sigsetmask, omask);
  243.  
  244.   if (error)
  245.     {
  246.       errno = error;
  247.       KPRINTF (("&errno = %lx, errno = %ld\n", &errno, errno));
  248.     }
  249.   if (!error && (mode & O_TRUNC) && (amode != MODE_NEWFILE))
  250.     syscall(SYS_ftruncate, fd, 0);
  251.  
  252.   /* return the descriptor */
  253.   return fd;
  254.  
  255. error:
  256.   /* free the file */
  257.   u.u_ofile[fd] = 0;
  258.   f->f_count--;
  259.   syscall (SYS_sigsetmask, omask);
  260.   errno = error;
  261.   KPRINTF (("&errno = %lx, errno = %ld\n", &errno, errno));
  262.   return -1;
  263. }
  264.